Computer systems are systems that manipulate data according to a list of instructions called a program. A program contains instructions that are understandable and executable by a computer's main processor. An operating system is a type of computer program that controls applications that can be run on the computer. Computer programs can include sub-system components that drive various processes when they are executed. The various processes that can be associated with one or more computer program sub-systems can communicate through a protocol called inter-process communication (IPC).
IPC can be used to facilitate the coordination of activities among different program processes that run concurrently in an operating system. An advantage of coordinating the activities of different program processes is that it enables a program to handle many user requests at the same time. Since even a single user request can result in multiple processes running in the operating system on the user's behalf, each of the processes should be provided with the capacity to communicate with the others. IPC interfaces make this possible. A type of IPC is called local procedure call (LPC).
LPC is a protocol that one computer program can use to request a service from a computer program located in the same computer. LPC uses the client/server model. The service requesting program is called the client and the service-providing program is called the server. LPC is a synchronous operation that requires that operations of the requesting program to be suspended until the results of the local procedure are returned. However, the use of lightweight processes or threads that share the same address space allows multiple LPCs to be performed concurrently.
LPC can be implemented using kernel “port” objects. As a part of the process, a server process first creates a port object with a well known name and then waits for client processes to connect. A client process can connect by “opening” the port object and sending a connect message. If the server accepts the connection a new unnamed port object is created for the connection. Port objects are securable kernel objects that allow a process to identify a process on the other side of the connection.
LPC is the fastest IPC that is used on the WINDOWS™ platform. Unfortunately, LPC does not possess request or connection timeout support, which can cause client processes to “hang” (be suspended) while waiting for server replies (there currently is not a mechanism for aborting a client call to the server). To overcome this limitation, conventional products perform client side LPC communication from a separate thread.
FIG. 1 illustrates the operation of LPC. It should be appreciated that client subsystem 101 and server subsystem 105 that are shown in FIG. 1 represent respective processes that execute on a computer. As shown in FIG. 1, initially, a client subsystem 101 spawns a separate thread 103a as shown at 103, for the purpose of communicating with server subsystem 105 via server side port object 109a that has been previously created (e.g., 109). The separate thread 103a is maintained during client-server communications. After a connection between the client subsystem and the server subsystem has been established in a manner such as is discussed above, at 115-117, the separate thread 103a can perform synchronous calls (see 119-125) to server subsystem 105 via server side port object 109a. LPC seeks to isolate possible delays from the main client process through the use of separate thread 103a. 
It should be appreciated that although this approach achieves better stability than regular LPC, it introduces extra memory and speed costs that are associated with maintaining the additional thread on the client side. Another approach is to tolerate the lack of client side LPC timeout support and address resultant crashing or hanging as it occurs. This approach is dependent on an unsatisfactory manual response to the problem. Still other approaches to addressing the lack of client timeout support require undesirable infrastructural changes at the operating system level and consequential core changes on both client subsystem and server subsystem sides at the application level.